home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 December / MACPOWER-1997-12.ISO.7z / MACPOWER-1997-12.ISO / AMUG / PROGRAMMING / Raven 1.2.sit / Raven 1.2 / Source / Foundation / Common / ZMiscUtils.cpp < prev    next >
Text File  |  1997-08-16  |  17KB  |  635 lines
  1. /*
  2.  *  File:       ZMiscUtils.cpp
  3.  *  Summary:       Misc utilities
  4.  *  Written by: Jesse Jones
  5.  *
  6.  *  Copyright ｩ 1996-1997 Jesse Jones. 
  7.  *    For conditions of distribution and use, see copyright notice in ZTypes.h  
  8.  *
  9.  *  Change History (most recent first):    
  10.  *
  11.  *         <8>     8/16/97    JDJ        ReportError now takes an OSStatus.
  12.  *         <7>     8/06/97    JDJ        ReportError uses StandardAlert.
  13.  *         <6>     7/27/97    JDJ        Added ByteSwap(double).
  14.  *         <5>     4/13/97    JDJ        TCodeTimer and TAverageTimer descend from MExitAction.
  15.  *         <4>     4/05/97    JDJ        Added a pragma unused.
  16.  *         <3>     1/09/97    JDJ        ReportError uses the Notification Manager if the
  17.  *                                    app is in the background.
  18.  *         <2>    12/05/96    JDJ        Added TAverageTimer.
  19.  *         <1>     1/13/96    JDJ        Created
  20.  */
  21.  
  22. #include <ZMiscUtils.h>
  23.  
  24. #include <Aliases.h>
  25. #include <Appearance.h>
  26. #include <Dialogs.h>
  27. #include <Errors.h>
  28. #include <Limits.h>
  29. #include <Memory.h>
  30. #include <Processes.h>
  31. #include <Resources.h>
  32. #include <StdIo.h>
  33. #include <String>
  34. #include <Timer.h>
  35. #include <ToolUtils.h>
  36.  
  37. #include <ZConstants.h>
  38. #include <ZDebug.h>
  39. #include <ZExceptions.h>
  40. #include <ZGestalt.h>
  41. #include <ZNotify.h>
  42. #include <ZStringUtils.h>
  43. #include <ZTypes.h>
  44.  
  45.  
  46. // ========================================================================================
  47. //    Internal Functions
  48. // ========================================================================================
  49.  
  50. //---------------------------------------------------------------
  51. //
  52. // IsInForeground
  53. //
  54. //---------------------------------------------------------------
  55. static bool IsInForeground()            
  56. {
  57.     Boolean inFront = true;
  58.  
  59.     ProcessSerialNumber    myProcess;
  60.     myProcess.highLongOfPSN = 0;
  61.     myProcess.lowLongOfPSN  = kCurrentProcess;
  62.  
  63.     ProcessSerialNumber    frontProcess;
  64.     OSErr err = GetFrontProcess(&frontProcess);
  65.     if (err == noErr)
  66.         err = SameProcess(&myProcess, &frontProcess, &inFront);
  67.     
  68.     ASSERT(err == noErr);
  69.     
  70.     return inFront;
  71. }
  72.  
  73.  
  74. //---------------------------------------------------------------
  75. //
  76. // DoStop
  77. //
  78. //---------------------------------------------------------------
  79. static short DoStop(ConstStr255Param str)    // takes a Str255 to avoid ambiguities with DoStop in ZDialogUtils.h
  80. {
  81.     InitCursor();
  82.     ParamText(str, "¥p", "¥p", "¥p");
  83.  
  84.     short item = StopAlert(130, nil);
  85.     
  86.     return item;
  87. }
  88.  
  89. #pragma mark -
  90.  
  91. // ========================================================================================
  92. //    Errors
  93. // ========================================================================================
  94.  
  95. //---------------------------------------------------------------
  96. //
  97. // ReportError (string, string, bool)
  98. //
  99. //---------------------------------------------------------------
  100. void ReportError(const string& errorStr, const string& supplementalStr, bool notify)
  101. {
  102.     #pragma unused(notify)
  103.     
  104. #if !DRAG_AND_DROP_APP                        // TNotify and StateBroadcaster are overkill for a simple d&d app
  105.     if (notify || !IsInForeground()) {        // ･･･ﾊThis seems like a pretty crude way to handle this...
  106.         TNotify* note = new TNotify(errorStr + supplementalStr);
  107.         note->Post();
  108.     
  109.     } else
  110. #endif
  111.     {
  112.         if (UGestalt::hasAppearanceMgr) {
  113.             AlertStdAlertParamRec params;
  114.             params.movable       = false;
  115.             params.helpButton    = false; 
  116.             params.filterProc    = nil;
  117.             params.defaultText   = (StringPtr) -1L;        // use default (ie "OK")
  118.             params.cancelText    = nil;        
  119.             params.otherText     = nil; 
  120.             params.defaultButton = ok;
  121.             params.cancelButton  = 0;
  122.             params.position      = kWindowDefaultPosition;
  123.  
  124.             short item;
  125.             OSErr err = StandardAlert(kAlertStopAlert, StrToPStr(errorStr), StrToPStr(supplementalStr), ¶ms, &item);
  126.             ASSERT(err == noErr);                        // don't throw
  127.  
  128.         } else
  129.             DoStop(StrToPStr(errorStr + supplementalStr));
  130.     }
  131. }
  132.  
  133.  
  134. //---------------------------------------------------------------
  135. //
  136. // ReportError (string, OSStatus, bool)
  137. //
  138. //---------------------------------------------------------------
  139. void ReportError(const string& errorStr, OSStatus err, bool notify)
  140. {
  141.     ASSERT(err != noErr);
  142.     
  143.     Str255 numberStr;
  144.     NumToString(err, numberStr);
  145.     
  146.     string supplementalStr = LoadRavenString(" because of an error #") + PStrToStr(numberStr);
  147.     
  148.     string text = LookUpString(203, err);
  149.     if (text != "")
  150.         supplementalStr +=  LoadRavenString(" (") + text + LoadRavenString(").");
  151.     else
  152.         supplementalStr += LoadRavenString(". (period)");
  153.  
  154.     ReportError(errorStr, supplementalStr, notify);
  155. }
  156.  
  157.  
  158. //---------------------------------------------------------------
  159. //
  160. // ReportError (string, TBaseException, bool)
  161. //
  162. //---------------------------------------------------------------
  163. void ReportError(const string& errorStr, const TBaseException& e, bool notify)
  164. {
  165.     if (const TSystemException* sysErr = dynamic_cast<const TSystemException*>(&e))
  166.         ReportError(errorStr, sysErr->mError, notify);
  167.     else
  168.         ReportError(errorStr, LoadRavenString(" because ") + e.what() + LoadRavenString(". (period)"), notify);
  169. }
  170.  
  171. #pragma mark -
  172.  
  173. // ========================================================================================
  174. //    Events
  175. // ========================================================================================
  176.  
  177. //---------------------------------------------------------------
  178. //
  179. // IsKeyDown
  180. //
  181. //---------------------------------------------------------------
  182. bool IsKeyDown(short keyCode)    
  183. {
  184.     Byte keyMap[16];
  185.  
  186.     GetKeys((UInt32 *) keyMap);
  187.     bool down = ((keyMap[keyCode >> 3] >> (keyCode & 7)) & 1) != 0;
  188.     
  189.     return down;
  190. }
  191.  
  192.  
  193. //---------------------------------------------------------------
  194. //
  195. // ExtractChar
  196. //
  197. // Returns the ASCII character corresponding to the keyDown or
  198. // keyUp event. This function can be used to find the character
  199. // that was pressed with the option key or to find out if the
  200. // shift key was held down with the command key. Note that this 
  201. // code is adapted from MacApp's TApplication::KeyEventToComponents. 
  202. //
  203. //---------------------------------------------------------------
  204. char ExtractChar(const EventRecord& event)
  205. {
  206.     ASSERT(event.what == keyDown || event.what == keyUp || event.what == autoKey);
  207.     
  208.     const int kMaskModifier = 0xF600;            // strip command and options keys from Modifiers 
  209.     const long kMaskASCII1 = 0x000000FF;        // get key from KeyTranslate return 
  210.     const long kMaskASCII2 = 0x00FF0000;        // get key from KeyTranslate return 
  211.     const short kUpKeyMask = 0x0080;
  212.  
  213.     // Now see if the command key is down. If it is, get the correct ASCII translation by
  214.     // masking the command key out and re-translating because the command key will
  215.     // mask the shift modifier.
  216.  
  217.     char theChar = (char) (event.message & charCodeMask);
  218.     ushort theKey = (ushort) ((event.message & keyCodeMask) >> 8);
  219.  
  220.     if ((event.modifiers & cmdKey) != 0 || (event.modifiers & optionKey) != 0) {
  221.         // Set the upkey bit so KeyTranslate doesn't do special deadkey processing. 
  222.         // See IM-V pp. 195 
  223.         ushort keyCodeParameter = (ushort) ((event.modifiers & kMaskModifier) | theKey | kUpKeyMask);
  224.  
  225.         Ptr keyTransTable = (Ptr) (GetScriptManagerVariable(smKCHRCache));
  226.  
  227.         ulong state = 0;
  228.         ulong keyInfo = KeyTranslate(keyTransTable, keyCodeParameter, &state);
  229.  
  230.         theChar = (char) (keyInfo & kMaskASCII1);
  231.         if (theChar == 0)
  232.             theChar = (char) ((keyInfo >> kMaskASCII2) & 16);
  233.     }
  234.     
  235.     return theChar;
  236. } 
  237.  
  238.  
  239. //---------------------------------------------------------------
  240. //
  241. // IsCommandPeriod
  242. //
  243. // Non-US keyboards sometimes use option key to generate period
  244. // so we'll strip off all the modifier keys before checking.
  245. //
  246. //---------------------------------------------------------------
  247. bool IsCommandPeriod(const EventRecord& event)
  248. {
  249.     bool cmdPeriod = false;
  250.     
  251.     if (event.what == keyDown)
  252.         if ((event.modifiers & cmdKey) != 0 && ExtractChar(event) == kPeriodChar)
  253.             cmdPeriod = true;
  254.  
  255.     return cmdPeriod;
  256. }
  257.  
  258. #pragma mark -
  259.  
  260. // ===================================================================================
  261. //    Misc
  262. // ===================================================================================
  263.  
  264. //---------------------------------------------------------------
  265. //
  266. // ByteSwap (double)
  267. //
  268. //---------------------------------------------------------------
  269. void ByteSwap(double& inData)
  270. {
  271.     ASSERT(sizeof(double) == 2*sizeof(long));
  272.     
  273.     long* data = reinterpret_cast<long*>(&inData);
  274.     
  275.     long temp = data[0];
  276.     data[0] = data[1];
  277.     data[1] = temp;
  278.     
  279.     byteswaplong(data[0]);
  280.     byteswaplong(data[1]);
  281. }
  282.  
  283.  
  284. //---------------------------------------------------------------
  285. //
  286. // BuildCRCTable
  287. //
  288. //---------------------------------------------------------------
  289. static unsigned long sCRCTable[256];
  290.  
  291. static void BuildCRCTable()
  292. {
  293.     const ulong kPolynomial = 0xEDB88320L;
  294.     
  295.     for (ulong i = 0; i < 256; i++) {
  296.         ulong value = i;
  297.         
  298.         for (int j = 8; j > 0; j--) {
  299.             if (value & 1)
  300.                 value = (value >> 1) ^ kPolynomial;
  301.             else
  302.                 value >>= 1;
  303.         }
  304.         
  305.         sCRCTable[i] = value;
  306.     }
  307. }
  308.  
  309.  
  310. //---------------------------------------------------------------
  311. //
  312. // ComputeCRC
  313. //
  314. // The code uses the CCITT-32 formula which is used by programs
  315. // like PKZIP and ARJ. The algorithm is taken from "The Data 
  316. // Compression Book" by Mark Nelson pg 446-447. 
  317. //
  318. //---------------------------------------------------------------
  319. ulong ComputeCRC(const void* buffer, ulong bytes, ulong crc)
  320. {
  321.     ASSERT(buffer != nil);
  322.     ASSERT(bytes < 16*1024L*1024L);
  323.     
  324.     static bool inited = false;
  325.     if (!inited) {
  326.         BuildCRCTable();
  327.         inited = true;
  328.     }
  329.         
  330.     // Note that these tests are not part of the original algorithm.
  331.     // They've been added because the prefs code sometimes tries to
  332.     // do a CRC on just a bool which doesn't work with the original 
  333.     // algorithm.
  334.     if (crc == 0xFFFFFFFFL && bytes == 1)        
  335.         crc = *((Byte *) buffer);
  336.         
  337.     else if (crc == 0xFFFFFFFFL && bytes == 2)
  338.         crc = *((ushort *) buffer);
  339.         
  340.     else if (crc == 0xFFFFFFFFL && bytes == 4)
  341.         crc = *((ulong *) buffer);
  342.  
  343.     else {
  344.         Byte* p = (Byte *) buffer;
  345.         
  346.         while (bytes--) {
  347.             ulong temp1 = (crc >> 8) & 0x00FFFFFFL;
  348.             ulong temp2 = sCRCTable[(crc ^ *p++) & 0xFF];
  349.             crc = temp1 ^ temp2;
  350.         }
  351.     }
  352.     
  353.     return crc;
  354. }
  355.  
  356.  
  357. //---------------------------------------------------------------
  358. //
  359. // GetMicroSeconds
  360. //
  361. //---------------------------------------------------------------
  362. long long GetMicroSeconds()
  363. {
  364.     UnsignedWide microSeconds;
  365.     Microseconds(µSeconds);
  366.  
  367.     long long seconds = microSeconds.hi;
  368.     seconds <<= 32;
  369.     seconds += microSeconds.lo;
  370.     
  371.     return seconds;
  372. }
  373.  
  374.  
  375. //---------------------------------------------------------------
  376. //
  377. // GetMilliSeconds
  378. //
  379. //---------------------------------------------------------------
  380. MilliSecond GetMilliSeconds()
  381. {
  382.     UnsignedWide microSeconds;
  383.     Microseconds(µSeconds);
  384.  
  385.     MilliSecond seconds = (MilliSecond) (microSeconds.hi*4294967L + microSeconds.lo/1000);        // 4294967L = 2^32 / 1000
  386.     
  387.     return seconds;
  388. }
  389.  
  390.  
  391. //---------------------------------------------------------------
  392. //
  393. // MilliSecondDelay
  394. //
  395. //---------------------------------------------------------------
  396. void MilliSecondDelay(MilliSecond delay)
  397. {
  398.     MilliSecond stopTime = GetMilliSeconds() + delay;
  399.  
  400.     while (GetMilliSeconds() < stopTime)
  401.         ;
  402. }
  403.  
  404. #pragma mark -
  405.  
  406. // ========================================================================================
  407. //    class TCodeTimer
  408. // ========================================================================================
  409.  
  410. //---------------------------------------------------------------
  411. //
  412. // TMOverhead
  413. //
  414. // Returns the overhead used by the Time Manager to set up a timer 
  415. // (in microseconds).
  416. //
  417. //---------------------------------------------------------------
  418. #if !RELEASE
  419. static long TMOverhead()
  420. {
  421.     long startTime = -LONG_MAX;
  422.  
  423.     TMTask task;
  424.     QElemPtr taskPtr = (QElemPtr) &task;
  425.  
  426.     task.tmAddr = nil;
  427.     task.tmWakeUp = 0;
  428.     task.tmReserved = 0;
  429.     
  430.     InsTime(taskPtr);
  431.     PrimeTime(taskPtr, startTime);
  432.     RmvTime(taskPtr);
  433.     
  434.     return -(startTime - task.tmCount);
  435. }
  436. #endif
  437.                         
  438.  
  439. //---------------------------------------------------------------
  440. //
  441. // TCodeTimer::~TCodeTimer
  442. //
  443. //---------------------------------------------------------------
  444. #if !RELEASE
  445. TCodeTimer::~TCodeTimer()
  446. {
  447.     // Returns the amount of unused time in tmCount (it should all be unused
  448.     // since we used a very large delay). The time will be in microseconds
  449.     // if the unused time is small or milliseconds if the delay is large.
  450.     ::RmvTime((QElemPtr) &mTask);
  451.     
  452.     long totalTime, endTime = mTask.tmCount;
  453.     
  454.     if (endTime < 0) 
  455.         totalTime = mStartTime - endTime;
  456.     else
  457.         totalTime = mStartTime + (1000L * endTime);
  458.  
  459.     totalTime = labs(totalTime) - TMOverhead();
  460.     if (totalTime < 0)                            // too quick to measure
  461.         totalTime = 0;
  462.  
  463.     DEBUGSTR("%s %.3f msecs.", mDescription, totalTime/1000.0);
  464. }
  465. #endif
  466.                         
  467.  
  468. //---------------------------------------------------------------
  469. //
  470. // TCodeTimer::TCodeTimer
  471. //
  472. //---------------------------------------------------------------
  473. #if !RELEASE
  474. TCodeTimer::TCodeTimer(const char* description)
  475. {
  476.     mDescription = description ? description : "Object lived for";
  477.     
  478.     // The Time Manager interprets positive numbers as millisecond values
  479.     // and negative numbers as negated microsecond values. Here we install
  480.     // a Time Manager task using microseconds that will wake up in 35 minutes.
  481.     mStartTime = -LONG_MAX;
  482.  
  483.     mTask.tmAddr     = nil;
  484.     mTask.tmWakeUp   = 0;
  485.     mTask.tmReserved = 0;
  486.     
  487.     ::InsTime((QElemPtr) &mTask);
  488.     ::PrimeTime((QElemPtr) &mTask, mStartTime);
  489. }
  490. #endif
  491.  
  492.  
  493. //---------------------------------------------------------------
  494. //
  495. // TCodeTimer::OnAbnormalExit
  496. //
  497. // The toolbox does not remove Time Manager tasks when an app shuts
  498. // down so we need to do it to prevent crashes.
  499. //
  500. //---------------------------------------------------------------
  501. #if !RELEASE
  502. void TCodeTimer::OnAbnormalExit()
  503. {
  504.     ::RmvTime((QElemPtr) &mTask);
  505. }
  506. #endif
  507.  
  508. #pragma mark -
  509.  
  510. // ========================================================================================
  511. //    class TAverageTimer
  512. // ========================================================================================
  513.  
  514. //---------------------------------------------------------------
  515. //
  516. // TAverageTimer::~TAverageTimer
  517. //
  518. //---------------------------------------------------------------
  519. #if !RELEASE
  520. TAverageTimer::~TAverageTimer()
  521. {
  522.     ASSERT(!mTiming);
  523.     
  524.     double average = mElapsedTime/mNumTimings;
  525.     
  526.     DEBUGSTR("%s %.3f msecs (average), %.3f (max), %.3f (min).", mDescription, average/1000.0, mMaxTime/1000.0, mMinTime/1000.0);
  527. }
  528. #endif
  529.                         
  530.  
  531. //---------------------------------------------------------------
  532. //
  533. // TAverageTimer::TAverageTimer
  534. //
  535. //---------------------------------------------------------------
  536. #if !RELEASE
  537. TAverageTimer::TAverageTimer(const char* description)
  538. {
  539.     mElapsedTime = 0.0;
  540.     mMaxTime     = 0;
  541.     mMinTime     = LONG_MAX;
  542.     mNumTimings  = 0;
  543.     mTiming      = false;
  544.     
  545.     mDescription = description ? description : "Object lived for";
  546. }
  547. #endif
  548.  
  549.  
  550. //---------------------------------------------------------------
  551. //
  552. // TAverageTimer::StartTiming
  553. //
  554. //---------------------------------------------------------------
  555. #if !RELEASE
  556. void TAverageTimer::StartTiming()
  557. {
  558.     ASSERT(!mTiming);
  559.  
  560.     // The Time Manager interprets positive numbers as millisecond 
  561.     // values and negative numbers as negated microsecond values. 
  562.     // Here we install a Time Manager task using microseconds that 
  563.     // will wake up in 35 minutes.
  564.     mStartTime = -LONG_MAX;
  565.  
  566.     mTask.tmAddr     = nil;
  567.     mTask.tmWakeUp   = 0;
  568.     mTask.tmReserved = 0;
  569.     
  570.     ::InsTime((QElemPtr) &mTask);
  571.     ::PrimeTime((QElemPtr) &mTask, mStartTime);
  572.     
  573.     mTiming = true;
  574. }
  575. #endif
  576.             
  577.  
  578. //---------------------------------------------------------------
  579. //
  580. // TAverageTimer::StopTiming
  581. //
  582. //---------------------------------------------------------------
  583. #if !RELEASE
  584. void TAverageTimer::StopTiming()
  585. {
  586.     ASSERT(mTiming);
  587.  
  588.     // Returns the amount of unused time in tmCount (it should all 
  589.     // be unused since we used a very large delay). The time will 
  590.     // be in microseconds if the unused time is small or milliseconds 
  591.     // if the delay is large.
  592.     ::RmvTime((QElemPtr) &mTask);
  593.     
  594.     long elapsed, endTime = mTask.tmCount;
  595.     
  596.     if (endTime < 0) 
  597.         elapsed = mStartTime - endTime;
  598.     else
  599.         elapsed = mStartTime + 1000L*endTime;
  600.  
  601.     elapsed = labs(elapsed) - TMOverhead();
  602.     if (elapsed < 0)                            // too quick to measure
  603.         elapsed = 0;
  604.     
  605.     if (elapsed < mMinTime)
  606.         mMinTime = elapsed;
  607.     
  608.     if (elapsed > mMaxTime)
  609.         mMaxTime = elapsed;
  610.     
  611.     mElapsedTime += elapsed;
  612.     mNumTimings++;
  613.     
  614.     mTiming = false;
  615. }
  616. #endif
  617.  
  618.  
  619. //---------------------------------------------------------------
  620. //
  621. // TAverageTimer::OnAbnormalExit
  622. //
  623. // The toolbox does not remove Time Manager tasks when an app shuts
  624. // down so we need to do it to prevent crashes.
  625. //
  626. //---------------------------------------------------------------
  627. #if !RELEASE
  628. void TAverageTimer::OnAbnormalExit()
  629. {
  630.     ::RmvTime((QElemPtr) &mTask);
  631. }
  632. #endif
  633.  
  634.  
  635.